

<!DOCTYPE html>
<html lang="zh-CN" data-default-color-scheme=auto>



<head>
  <meta charset="UTF-8">
  <link rel="apple-touch-icon" sizes="76x76" href="/img/Mine.jpg">
  <link rel="icon" href="/img/Mine.jpg">
  <meta name="viewport" content="width=device-width, initial-scale=1.0, maximum-scale=5.0, shrink-to-fit=no">
  <meta http-equiv="x-ua-compatible" content="ie=edge">
  
  <meta name="theme-color" content="#2f4154">
  <meta name="author" content="Chiam">
  <meta name="keywords" content="算法，安全">
  
    <meta name="description" content="『操作系统』 进程的描述与控制 Part 1 前驱图与程序执行               文章目录                   2.1                 前趋图和程序执行                          2.1.1                         程序的顺序执行及其特征">
<meta property="og:type" content="article">
<meta property="og:title" content="『操作系统』  进程的描述与控制 Part 1 前驱图与程序执行">
<meta property="og:url" content="http://example.com/2023/12/06/%E3%80%8E%E6%93%8D%E4%BD%9C%E7%B3%BB%E7%BB%9F%E3%80%8F%20%20%E8%BF%9B%E7%A8%8B%E7%9A%84%E6%8F%8F%E8%BF%B0%E4%B8%8E%E6%8E%A7%E5%88%B6%20Part%201%20%E5%89%8D%E9%A9%B1%E5%9B%BE%E4%B8%8E%E7%A8%8B%E5%BA%8F%E6%89%A7%E8%A1%8C/index.html">
<meta property="og:site_name" content="Chiam 的个人主页">
<meta property="og:description" content="『操作系统』 进程的描述与控制 Part 1 前驱图与程序执行               文章目录                   2.1                 前趋图和程序执行                          2.1.1                         程序的顺序执行及其特征">
<meta property="og:locale" content="zh_CN">
<meta property="article:published_time" content="2023-12-05T16:11:43.812Z">
<meta property="article:modified_time" content="2023-12-05T16:18:03.307Z">
<meta property="article:author" content="Chiam">
<meta property="article:tag" content="算法，安全">
<meta name="twitter:card" content="summary_large_image">
  
  
  
  <title>『操作系统』  进程的描述与控制 Part 1 前驱图与程序执行 - Chiam 的个人主页</title>

  <link  rel="stylesheet" href="https://lib.baomitu.com/twitter-bootstrap/4.6.1/css/bootstrap.min.css" />



  <link  rel="stylesheet" href="https://lib.baomitu.com/github-markdown-css/4.0.0/github-markdown.min.css" />

  <link  rel="stylesheet" href="https://lib.baomitu.com/hint.css/2.7.0/hint.min.css" />

  <link  rel="stylesheet" href="https://lib.baomitu.com/fancybox/3.5.7/jquery.fancybox.min.css" />



<!-- 主题依赖的图标库，不要自行修改 -->
<!-- Do not modify the link that theme dependent icons -->

<link rel="stylesheet" href="//at.alicdn.com/t/font_1749284_hj8rtnfg7um.css">



<link rel="stylesheet" href="//at.alicdn.com/t/font_1736178_lbnruvf0jn.css">


<link  rel="stylesheet" href="/css/main.css" />


  <link id="highlight-css" rel="stylesheet" href="/css/highlight.css" />
  
    <link id="highlight-css-dark" rel="stylesheet" href="/css/highlight-dark.css" />
  



  
<link rel="stylesheet" href="/css/custom.css">



  <script id="fluid-configs">
    var Fluid = window.Fluid || {};
    Fluid.ctx = Object.assign({}, Fluid.ctx)
    var CONFIG = {"hostname":"example.com","root":"/","version":"1.9.5-a","typing":{"enable":true,"typeSpeed":70,"cursorChar":"_","loop":false,"scope":[]},"anchorjs":{"enable":true,"element":"h1,h2,h3,h4,h5,h6","placement":"left","visible":"hover","icon":"❡"},"progressbar":{"enable":true,"height_px":3,"color":"#29d","options":{"showSpinner":false,"trickleSpeed":100}},"code_language":{"enable":true,"default":"TEXT"},"copy_btn":true,"image_caption":{"enable":true},"image_zoom":{"enable":true,"img_url_replace":["",""]},"toc":{"enable":true,"placement":"right","headingSelector":"h1,h2,h3,h4,h5,h6","collapseDepth":2},"lazyload":{"enable":true,"loading_img":"/img/loading.gif","onlypost":false,"offset_factor":2},"web_analytics":{"enable":false,"follow_dnt":true,"baidu":null,"google":{"measurement_id":null},"tencent":{"sid":null,"cid":null},"woyaola":null,"cnzz":null,"leancloud":{"app_id":null,"app_key":null,"server_url":null,"path":"window.location.pathname","ignore_local":false}},"search_path":"/local-search.xml","include_content_in_search":true};

    if (CONFIG.web_analytics.follow_dnt) {
      var dntVal = navigator.doNotTrack || window.doNotTrack || navigator.msDoNotTrack;
      Fluid.ctx.dnt = dntVal && (dntVal.startsWith('1') || dntVal.startsWith('yes') || dntVal.startsWith('on'));
    }
  </script>
  <script  src="/js/utils.js" ></script>
  <script  src="/js/color-schema.js" ></script>
  


  
<meta name="generator" content="Hexo 6.3.0"></head>


<body>
  

  <header>
    

<div class="header-inner" style="height: 70vh;">
  <nav id="navbar" class="navbar fixed-top  navbar-expand-lg navbar-dark scrolling-navbar">
  <div class="container">
    <a class="navbar-brand" href="/">
      <strong>Chiam&#39;s Blogs</strong>
    </a>

    <button id="navbar-toggler-btn" class="navbar-toggler" type="button" data-toggle="collapse"
            data-target="#navbarSupportedContent"
            aria-controls="navbarSupportedContent" aria-expanded="false" aria-label="Toggle navigation">
      <div class="animated-icon"><span></span><span></span><span></span></div>
    </button>

    <!-- Collapsible content -->
    <div class="collapse navbar-collapse" id="navbarSupportedContent">
      <ul class="navbar-nav ml-auto text-center">
        
          
          
          
          
            <li class="nav-item">
              <a class="nav-link" href="/">
                
                <span>首页</span>
              </a>
            </li>
          
        
          
          
          
          
            <li class="nav-item">
              <a class="nav-link" href="/archives/">
                
                <span>归档</span>
              </a>
            </li>
          
        
          
          
          
          
            <li class="nav-item">
              <a class="nav-link" href="/categories/">
                
                <span>分类</span>
              </a>
            </li>
          
        
          
          
          
          
            <li class="nav-item">
              <a class="nav-link" href="/about/">
                
                <span>关于</span>
              </a>
            </li>
          
        
          
          
          
          
            <li class="nav-item">
              <a class="nav-link" href="/links/">
                
                <span>友链</span>
              </a>
            </li>
          
        
        
          <li class="nav-item" id="search-btn">
            <a class="nav-link" target="_self" href="javascript:;" data-toggle="modal" data-target="#modalSearch" aria-label="Search">
              <i class="iconfont icon-search"></i>
            </a>
          </li>
          
        
        
          <li class="nav-item" id="color-toggle-btn">
            <a class="nav-link" target="_self" href="javascript:;" aria-label="Color Toggle">
              <i class="iconfont icon-dark" id="color-toggle-icon"></i>
            </a>
          </li>
        
      </ul>
    </div>
  </div>
</nav>

  

<div id="banner" class="banner" parallax=true
     style="background: url('/img/default.png') no-repeat center center; background-size: cover;">
  <div class="full-bg-img">
    <div class="mask flex-center" style="background-color: rgba(0, 0, 0, 0.3)">
      <div class="banner-text text-center fade-in-up">
        <div class="h2">
          
            <span id="subtitle" data-typed-text="『操作系统』  进程的描述与控制 Part 1 前驱图与程序执行"></span>
          
        </div>

        
          
  <div class="mt-3">
    
    
      <span class="post-meta">
        <i class="iconfont icon-date-fill" aria-hidden="true"></i>
        <time datetime="2023-12-06 00:11" pubdate>
          2023年12月6日 凌晨
        </time>
      </span>
    
  </div>

  <div class="mt-1">
    
      <span class="post-meta mr-2">
        <i class="iconfont icon-chart"></i>
        
          8.6k 字
        
      </span>
    

    
      <span class="post-meta mr-2">
        <i class="iconfont icon-clock-fill"></i>
        
        
        
          72 分钟
        
      </span>
    

    
    
  </div>


        
      </div>

      
    </div>
  </div>
</div>

</div>

  </header>

  <main>
    
      

<div class="container-fluid nopadding-x">
  <div class="row nomargin-x">
    <div class="side-col d-none d-lg-block col-lg-2">
      

    </div>

    <div class="col-lg-8 nopadding-x-md">
      <div class="container nopadding-x-md" id="board-ctn">
        <div id="board">
          <article class="post-content mx-auto">
            <h1 id="seo-header">『操作系统』  进程的描述与控制 Part 1 前驱图与程序执行</h1>
            
            
              <div class="markdown-body">
                
                <h1 id="『操作系统』-进程的描述与控制-Part-1-前驱图与程序执行"><a href="#『操作系统』-进程的描述与控制-Part-1-前驱图与程序执行" class="headerlink" title="『操作系统』 进程的描述与控制 Part 1 前驱图与程序执行"></a>『操作系统』 进程的描述与控制 Part 1 前驱图与程序执行</h1><p></p>
<div class="toc">
    <h3>
        <a name="t0" one-link-mark="yes"></a><a name="t0" one-link-mark="yes"></a>文章目录
    </h3>
    <ul>
        <li><a href="#21___4" target="_self" one-link-mark="yes">2.1
                前趋图和程序执行</a></li>
        <li><ul>
                <li><a href="#211___5" target="_self" one-link-mark="yes">2.1.1
                        程序的顺序执行及其特征</a></li>
                <li><ul>
                        <li><a href="#1___6" target="_self" one-link-mark="yes">1.
                                程序的顺序执行</a></li>
                        <li><a href="#2_9" target="_self" one-link-mark="yes">2.程序顺序执行时的特征</a></li>
                    </ul></li>
                <li><a href="#212___16" target="_self" one-link-mark="yes">2.1.2
                        前趋图</a></li>
                <li><a href="#213___28" target="_self" one-link-mark="yes">2.1.3
                        程序的并发执行及其特征</a></li>
                <li><ul>
                        <li><a href="#1__29" target="_self" one-link-mark="yes">1.
                                程序的并发执行</a></li>
                        <li><a href="#2___33" target="_self" one-link-mark="yes">2.
                                程序并发执行时的特征</a></li>
                        <li><a href="#3_46" target="_self" one-link-mark="yes">3.程序并发执行的描述</a></li>
                        <li><a href="#4_58" target="_self" one-link-mark="yes">4.采用并发程序设计的目的</a></li>
                        <li><ul>
                                <li><a href="#_63" target="_self" one-link-mark="yes">练习题</a></li>
                            </ul></li>
                    </ul></li>
            </ul></li>
        <li><a href="#22___76" target="_self" one-link-mark="yes">2.2
                进程的描述</a></li>
        <li><ul>
                <li><ul>
                        <li><a href="#1___Process__78" target="_self"
                            one-link-mark="yes">1. 进程（ Process ）的定义</a></li>
                        <li><a href="#2__90" target="_self" one-link-mark="yes">2.
                                进程的特征</a></li>
                        <li><a href="#3__98" target="_self" one-link-mark="yes">3.
                                进程与程序的区别</a></li>
                        <li><ul>
                                <li><a href="#_108" target="_self" one-link-mark="yes">练习题</a></li>
                            </ul></li>
                        <li><a href="#4_121" target="_self" one-link-mark="yes">4、进程的基本状态-三态模型</a></li>
                        <li><ul>
                                <li><a href="#_140" target="_self" one-link-mark="yes">练习题</a></li>
                            </ul></li>
                        <li><a href="#5_153" target="_self" one-link-mark="yes">5、五态模型</a></li>
                        <li><a href="#6_169" target="_self" one-link-mark="yes">6、七态模型</a></li>
                        <li><ul>
                                <li><a href="#_203" target="_self" one-link-mark="yes">练习题</a></li>
                            </ul></li>
                        <li><a href="#7_213" target="_self" one-link-mark="yes">7、进程控制块</a></li>
                        <li><ul>
                                <li><a href="#_242" target="_self" one-link-mark="yes">练习题</a></li>
                                <li><a href="#_268" target="_self" one-link-mark="yes">练习题</a></li>
                                <li><a href="#_312" target="_self" one-link-mark="yes">练习题</a></li>
                            </ul></li>
                    </ul></li>
            </ul></li>
        <li><a href="#23___372" target="_self" one-link-mark="yes">2.3
                进程控制</a></li>
        <li><ul>
                <li><a href="#231___387" target="_self" one-link-mark="yes">2.3.1
                        进程创建</a></li>
                <li><ul>
                        <li><a href="#1___388" target="_self" one-link-mark="yes">1.
                                进程图</a></li>
                        <li><a href="#2_399" target="_self" one-link-mark="yes">2.引起创建进程的事件</a></li>
                        <li><ul>
                                <li><a href="#_406" target="_self" one-link-mark="yes">练习题</a></li>
                            </ul></li>
                        <li><a href="#3_416" target="_self" one-link-mark="yes">3.进程的创建过程</a></li>
                    </ul></li>
                <li><a href="#232___429" target="_self" one-link-mark="yes">2.3.2
                        进程终止</a></li>
                <li><ul>
                        <li><a href="#1___430" target="_self" one-link-mark="yes">1.
                                引起进程终止的事件</a></li>
                    </ul></li>
                <li><a href="#233__446" target="_self" one-link-mark="yes">2.3.3
                        进程的阻塞与唤醒</a></li>
                <li><ul>
                        <li><a href="#1___448" target="_self" one-link-mark="yes">1.
                                引起进程阻塞的事件</a></li>
                        <li><a href="#2_454" target="_self" one-link-mark="yes">2.进程阻塞过程</a></li>
                        <li><a href="#3_459" target="_self" one-link-mark="yes">3.进程唤醒过程</a></li>
                    </ul></li>
                <li><a href="#234__464" target="_self" one-link-mark="yes">2.3.4
                        进程挂起/激活</a></li>
                <li><ul>
                        <li><a href="#1_466" target="_self" one-link-mark="yes">1.进程的挂起</a></li>
                        <li><a href="#2_474" target="_self" one-link-mark="yes">2.进程激活</a></li>
                        <li><ul>
                                <li><a href="#_483" target="_self" one-link-mark="yes">练习题</a></li>
                            </ul></li>
                    </ul></li>
            </ul></li>
    </ul>
</div>
<p></p>
<h1>
    <a name="t1" one-link-mark="yes"></a><a name="t1" one-link-mark="yes"></a><a
        id="21___4" one-link-mark="yes"></a>2.1 前趋图和程序执行
</h1>
<h2>
    <a name="t2" one-link-mark="yes"></a><a name="t2" one-link-mark="yes"></a><a
        id="211___5" one-link-mark="yes"></a>2.1.1 程序的顺序执行及其特征
</h2>
<h3>
    <a name="t3" one-link-mark="yes"></a><a name="t3" one-link-mark="yes"></a><a
        id="1___6" one-link-mark="yes"></a>1. 程序的顺序执行
</h3>
<p>一个程序由若干个程序段组成，而这些程序段的执行必须是顺序的，这种程序执行的方式就称为程序的顺序执行。</p>
<h3>
    <a name="t4" one-link-mark="yes"></a><a name="t4" one-link-mark="yes"></a><a
        id="2_9" one-link-mark="yes"></a>2.程序顺序执行时的特征
</h3>
<p>
    (1)
    <mark>顺序性</mark>
    <br> 处理机的操作严格按照程序所规定的顺序执行。<br> (2)
    <mark>封闭性</mark>
    <br> 程序一旦开始执行，其计算结果不受外界因素的影响。<br> (3)
    <mark>可再现性</mark>
    <br> 程序执行的结果与它的执行速度无关(即与时间无关)，而只与初始条件有关
</p>
<h2>
    <a name="t5" one-link-mark="yes"></a><a name="t5" one-link-mark="yes"></a><a
        id="212___16" one-link-mark="yes"></a>2.1.2 前趋图
</h2>
前驱图是一个
DAG，其用于描述进程间执行的先后次序，图中的每个结点用于表示一个进程或一个程序段，结点间的有向边表示两个结点间存在的偏序关系(前趋关系)。

<p>进程间的前趋关系用 → 来表示，若进程 Pi 和 Pj 间存在前趋关系，可表示为 (Pi,Pj)∈→，即：Pi→Pj，表示 Pj 在执行前<br>Pi 必须完成。</p>
<p>在前驱图中，将没有前驱的结点称为初始结点，将没有后继的结点称为终止结点，此外，每个结点还具有一个价值，用于表示该结点所含有的进程的执行时间</p>
<ul>
    <li>结点 ： 描述一个程序段或进程，或一条语句。</li>
    <li>有向边： 结点之间的前趋关系“-&gt;”</li>
    <li>Pi-&gt;Pj ：Pi 必须在 Pj 开始之前完成，则 Pi是Pj的直接前趋，Pj是Pi的直接后继</li>
    <li>初始结点: 没有前趋的结点</li>
    <li>终止结点: 没有后继的结点</li>
    <li>重量: 结点的程序量或执行时间</li>
</ul>
<p>
    <img
        src="https://img-blog.csdnimg.cn/20201011145330838.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzQ2MDIyNA==,size_16,color_FFFFFF,t_70#pic_center" srcset="/img/loading.gif" lazyload
        alt="在这里插入图片描述"><br>
    <mark>前趋图中绝对不能出现循环</mark>
</p>
<h2>
    <a name="t6" one-link-mark="yes"></a><a name="t6" one-link-mark="yes"></a><a
        id="213___28" one-link-mark="yes"></a>2.1.3 程序的并发执行及其特征
</h2>
<h3>
    <a name="t7" one-link-mark="yes"></a><a name="t7" one-link-mark="yes"></a><a
        id="1__29" one-link-mark="yes"></a>1. 程序的顺序执行
</h3>
一个应用程序由若干程序段组成，每一程序段完成特定的功能，他们在执行时，都要按照某种先后次序执行，仅当前一程序段执行完后，再运行后一程序段，这种执行过程被称为程序的顺序执行。

<p>程序顺序执行时，具有以下三个特征：</p>
<p>顺序性：处理机的操作严格按程序规定顺序执行<br>封闭性：程序一旦开始执行，其计算结果不受外界因素影响<br>可再现性：程序执行只要初始条件一样，不论如何停顿，重复执行多少次结果都一样</p>
<h3>
    <a name="t7" one-link-mark="yes"></a><a name="t7" one-link-mark="yes"></a><a
        id="1__29" one-link-mark="yes"></a>2. 程序的并发执行
</h3>
<p>
    例：在系统中有n个作业，每个作业都有三个处理步骤，输入数据、处理、输出，即Ii,Ci,Pi (i=1,2,3,…,n)。<br>
    这些作业在系统中执行时是对时间的偏序，有些操作必须在其它操作之前执行，这是有序的，但有些操作是可以同时执行的。
</p>
<h3>
    <a name="t8" one-link-mark="yes"></a><a name="t8" one-link-mark="yes"></a><a
        id="2___33" one-link-mark="yes"></a>3. 程序并发执行时的特征
</h3>
<p>
    (1)
    <mark>间断性</mark>
    <br>
    在多道程序设计的环境下，程序是并发执行的，由于它们共享系统资源，以及为完成同一项任务而相互合作，致使在这些并发执行的程序之间形成了相互制约的关系。<br>
    相互制约导致并发程序具有“执行-暂停-执行”这种间断性的活动规律。<br> (2)
    <mark>失去封闭性</mark>
    <br>
    程序在并发执行时，多道程序共享系统的资源，因而这些资源的状态由多道程序来改变，程序运行失去封闭性。一程序的运行受到其他程序的影响。<br>
    (3)
    <mark>不可再现性</mark>
    <br> 程序在并发执行时，失去封闭性导致其失去可再现性。<br> (4)
    <mark>程序与计算不再一一对应</mark>
    <img
        src="https://img-blog.csdnimg.cn/20201011150440954.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzQ2MDIyNA==,size_16,color_FFFFFF,t_70#pic_center" srcset="/img/loading.gif" lazyload
        alt="在这里插入图片描述">
</p>
<p>
    <strong>程序并发执行时失去程序的封闭性和可再现性的主要原因是什么？</strong><br> <strong>解答：</strong>
    并发运行的程序相互制约
</p>
<h3>
    <a name="t9" one-link-mark="yes"></a><a name="t9" one-link-mark="yes"></a><a
        id="3_46" one-link-mark="yes"></a>4.程序并发执行的描述
</h3>
<ul>
    <li>若干个程序段同时在系统中运行，这些程序的执行在时间上是重迭的；</li>
    <li>一个程序段的执行尚未结束，另一个程序段的执行已经开始；</li>
    <li>即使这种重迭是很小的，也称这几个程序段是并发执行的。</li>
</ul>
<p>
    <strong>描述</strong><br> cobegin<br> S1;S2;S3;…;SN<br>
    coend;<br>
    其中Si(i=1,2,3,…,n)表示n个语句（程序段），这n个语句用cobegin和coend括起来表示这n个语句是可以并发执行的。<br>
    <mark>co是concurrent的头两个字符。</mark>
    这是Dijkstra提出的。
</p>
<h3>
    <a name="t10" one-link-mark="yes"></a><a name="t10"
        one-link-mark="yes"></a><a id="4_58" one-link-mark="yes"></a>5.采用并发程序设计的目的
</h3>
<ul>
    <li>充分发挥硬件的并行性，消除处理器和I/O 设备的互等现象，提高系统效率。</li>
    <li>并发程序设计是多道程序设计的基础，多道程序的实质就是把并发程序设计引入到单处理器的系统中。</li>
</ul>
<h4>
    <a id="_63" one-link-mark="yes"></a>练习题
</h4>
<p>
    1.[2017考研真题 28]与单道系统相比，多道程序系统的优点是（D）<br>
    <mark>Ⅰ．CPU利用率高</mark>
    <br> Ⅱ．系统开销小<br>
    <mark>Ⅲ．系统吞吐率大</mark>
    <br>
    <mark>Ⅳ．I/O设备利用率高</mark>
</p>
<p>
    A．仅 Ⅰ、Ⅲ<br> B．仅 Ⅰ、Ⅳ<br> C．仅 Ⅱ、Ⅳ<br>
    <mark>D．仅 Ⅰ、Ⅲ 、Ⅳ</mark>
</p>
<h1>
    <a name="t11" one-link-mark="yes"></a><a name="t11"
        one-link-mark="yes"></a><a id="22___76" one-link-mark="yes"></a>2.2
    进程的描述
</h1>
<p>在多道程序设计的环境下，为了描述程序在计算机系统内的执行情况，必须引人新的概念——进程。</p>
<h3>
    <a name="t12" one-link-mark="yes"></a><a name="t12"
        one-link-mark="yes"></a><a id="1___Process__78" one-link-mark="yes"></a>1.
    进程（ Process ）的定义
</h3>
<p>进程是一个可并发执行的程序在其数据集上的一次运行过程，是操作系统进行资源分配的单位,进程表示资源的占用和所要做的工作。</p>
<p>
    <strong>各种不同的进程定义</strong>
</p>
<ul>
    <li>行为的一个规则叫做程序，程序在处理机上执行时所发生的活动称为进程（Dijkstra)。</li>
    <li>进程是这样的计算部分，它是可以和其它计算并行的一个计算。(Donovan)</li>
    <li>进程（有时称为任务）是一个程序与其数据一道通过处理机的执行所发生的活动。（Alan.C. Shaw)</li>
    <li>进程是执行中的程序。（Ken Thompson and Dennis Ritchie )</li>
</ul>
<p>
    <strong>进程的定义</strong>：可并发执行的程序在一个数据集合上的一次执行过程。<br>
    进程是进程实体的运行过程，是系统进行资源分配和调度的一个独立单位。
</p>
<h3>
    <a name="t13" one-link-mark="yes"></a><a name="t13"
        one-link-mark="yes"></a><a id="2__90" one-link-mark="yes"></a>2.
    进程的特征
</h3>
<p>
    <mark>动态性、并发性、独立性、异步性、结构性</mark>
    <br> (1)动态性——进程是程序在处理机上的一次执行过程。具有生命期。<br>
    (2)并发性——多个进程实体同存于内存中，在一段时间内同时运行。以提高资源利用率。<br> (3)
    独立性——进程实体是一个能独立运行、独立分配资源和独立接受调度的基本单位，而程序则不是。<br> (4)
    异步性——进程按各自独立的、不可预知的速度向前推进。<br> (5)
    结构性——进程控制块(PCB)+程序段+相关的数据段=进程实体。
</p>
<h3>
    <a name="t14" one-link-mark="yes"></a><a name="t14"
        one-link-mark="yes"></a><a id="3__98" one-link-mark="yes"></a>3.
    进程与程序的区别
</h3>
<ul>
    <li>进程是动态的，程序是静态的</li>
    <li>进程是暂时的，程序是永久的</li>
    <li>进程与程序的组成不同：<br> 程序是指令的有序集合；<br>
        进程包括程序、数据和进程控制块(即进程状态信息）
    </li>
    <li>进程与程序的对应关系：<br> 无一一对应关系(一个进程可顺序执行多个程序;一个程序可由多个进程共用）<br>
        <img
        src="https://img-blog.csdnimg.cn/20201011212236685.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzQ2MDIyNA==,size_16,color_FFFFFF,t_70#pic_center" srcset="/img/loading.gif" lazyload
        alt="在这里插入图片描述"></li>
</ul>
<h4>
    <a id="_108" one-link-mark="yes"></a>练习题
</h4>
<p>
    操作系统引入进程后，不能（C）<br> A．提高资源的利用率<br> B．正确描述程序的执行情况<br>
    <mark>C．提高用户编程能力</mark>
    <br> D．允许一个程序同时被多个用户调用
</p>
<p>
    <strong>进程的类型</strong><br>
    （1）系统进程：执行操作系统核心代码的进程。系统进程起着资源管理和控制的作用。<br> （2）用户进程：执行用户程序的进程。<br>
    （3）计算进程，I/O进程。<br> （4）前台进程，后台进程。
</p>
<h3>
    <a name="t15" one-link-mark="yes"></a><a name="t15"
        one-link-mark="yes"></a><a id="4_121" one-link-mark="yes"></a>4、进程的基本状态-三态模型
</h3>
<ul>
    <li>运行态（running）：进程占有处理器正在运行。</li>
    <li>就绪态（ready）：进程具备运行条件，等待系统分配处理器以便运行。</li>
    <li>等待态（wait）：又称为阻塞（blocked）态或睡眠（sleep）态，进程不具备运行条件，正在等待某个事件的完成。</li>
</ul>
<p>
    <mark>不同系统设置的进程状态数目不同</mark>
</p>
<p>
    <strong>三态转换图</strong><br> <img
        src="https://img-blog.csdnimg.cn/20201011213554816.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzQ2MDIyNA==,size_16,color_FFFFFF,t_70#pic_center" srcset="/img/loading.gif" lazyload
        alt="在这里插入图片描述"><br> <strong>正经图来了</strong><br> <img
        src="https://img-blog.csdnimg.cn/20201011213827238.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzQ2MDIyNA==,size_16,color_FFFFFF,t_70#pic_center" srcset="/img/loading.gif" lazyload
        alt="在这里插入图片描述"><br> <strong>引起进程状态转换的具体原因</strong>
</p>
<ul>
    <li>运行态→等待态：等待使用资源或某事件发生；</li>
    <li>等待态→就绪态：资源得到满足或事件发生；</li>
    <li>运行态→就绪态：运行时间片到；出现有更高优先权进程。</li>
    <li>就绪态→运行态：CPU空闲时选择一个就绪进程。<br> <img
        src="https://img-blog.csdnimg.cn/20201011214122979.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzQ2MDIyNA==,size_16,color_FFFFFF,t_70#pic_center" srcset="/img/loading.gif" lazyload
        alt="在这里插入图片描述"></li>
</ul>
<h4>
    <a id="_140" one-link-mark="yes"></a>练习题
</h4>
<p>
    1.[2015考研题 25] 下列选项中会导致进程从执行态变为就绪态的事件是（D）<br> A．执行P(wait)操作<br>
    B．申请内存失败<br> C．启动I/O 设备<br>
    <mark>D．被高优先级进程抢占</mark>
</p>
<p>
    2.[2014考研题 26] 一个进程的读磁盘操作完成后，操作系统针对该进程必做的是（A）<br>
    <mark>A．修改进程状态为就绪态</mark>
    <br> B．降低进程优先级<br> C．给进程分配用户内存空间<br> D．增加进程时间片大小
</p>
<h3>
    <a name="t16" one-link-mark="yes"></a><a name="t16"
        one-link-mark="yes"></a><a id="5_153" one-link-mark="yes"></a>5、五态模型
</h3>
<p>五态模型在三态模型的基础上引进了新建态和终止态。</p>
<ul>
    <li>新建态—对应进程刚被创建的状态。为一个新进程创建必要的管理信息，它并没有被提交，而是在等待操作系统完成创建进程的必要操作。</li>
    <li>终止态—进程的终止状态。首先，等待操作系统进行善后，然后，退出主存。进入终止态的进程不再执行，但依然临时保留在系统中等待善后。一旦其他进程完成了对终止态进程的信息抽取之后，系统将删除该进程。</li>
</ul>
<p>
    <img
        src="https://img-blog.csdnimg.cn/20201011220129114.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzQ2MDIyNA==,size_16,color_FFFFFF,t_70#pic_center" srcset="/img/loading.gif" lazyload
        alt="在这里插入图片描述"><br> <strong>进程状态转换的具体原因</strong>
</p>
<ul>
    <li>NULL→新建态：创建一个子进程。</li>
    <li>新建态→就绪态：系统完成了进程创建操作，且当前系统的性能和内存的容量均允许。</li>
    <li>运行态→终止态：一个进程到达自然结束点，或出现了无法克服的错误，或被操作系统所终结，或被其他有终止权的进程所终结。</li>
    <li>终止态→NULL：完成善后操作。</li>
    <li>就绪态→终止态：某些操作系统允许父进程终结子进程。</li>
    <li>等待态→终止态：某些操作系统允许父进程终结子进程。</li>
</ul>
<h3>
    <a name="t17" one-link-mark="yes"></a><a name="t17"
        one-link-mark="yes"></a><a id="6_169" one-link-mark="yes"></a>6、七态模型
</h3>
<p>
    (1)为什么要有“挂起”状态?<br>
    由于进程的不断创建，系统资源已不能满足进程运行的要求，就必须把某些进程挂起（suspend），对换到磁盘镜像区中，暂时不参与进程调度，起到平滑系统负载的目的。<br>
    (2)引起挂起状态的原因
</p>
<ul>
    <li>终端用户的需要：终端用户在自己程序运行中发现问题要求使正在执行的进程暂停执行而使进程处于挂起状态。</li>
    <li>父进程的需要：父进程为了考查和修改某个子进程，或者协调各子进程间的活动，需要将该子进程挂起。</li>
    <li>操作系统的需要：操作系统为了检查运行中的资源使用情况或进行记帐，而将某些进程挂起。</li>
    <li>对换的需要：为了提高内存的利用率，而将内存中某些进程挂起，以调进其它程序运行。</li>
    <li>负荷调节的需要：由于工作负荷较重，而将一些不重要的进程挂起，以保证系统能正常运行（实时操作系统） 。</li>
</ul>
<p>(3)进程增加的两个新状态</p>
<ul>
    <li>挂起就绪态（ready suspend）：表明进程具备运行条件但目前在辅助存储器中，当它被对换到主存才能被调度执行。</li>
    <li>挂起等待态（blocked suspend）：表明进程正在等待某一个事件且在辅助存储器中。</li>
</ul>
<p>
    <img
        src="https://img-blog.csdnimg.cn/20201011221325732.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzQ2MDIyNA==,size_16,color_FFFFFF,t_70#pic_center" srcset="/img/loading.gif" lazyload
        alt="在这里插入图片描述"><br> (4)引起进程状态转换的具体原因
</p>
<ul>
    <li>等待态→挂起等待态：系统根据当前资源状况和性能要求，决定将一个等待态进程对换出去成为挂起等待态；</li>
    <li>就绪态→挂起就绪态：系统根据当前资源状况和性能要求，决定把就绪态进程对换出去成为挂起就绪态。</li>
    <li>挂起等待态→挂起就绪态：引起进程等待的事件发生之后，相应的挂起等待态进程将转换为挂起就绪态。</li>
    <li>挂起等待态→等待态：当一个进程等待一个事件时，原则上不需要把它调入内存。但是，当其它进程退出后，主存已经有了足够的自由空间，而某个挂起等待态进程具有较高的优先级并且操作系统已经得知导致它阻塞的事件即将结束，便可能发生这一状态变化。</li>
    <li>挂起就绪态→就绪态：内存中没有就绪态进程，或挂起就绪态进程具有比就绪态进程更高的优先级，将把挂起就绪态进程转换成就绪态。</li>
    <li>运行态→挂起就绪态：当一个高优先级等待进程的等待事件结束后，它将抢占CPU，而此时主存不够，从而可能导致正在运行的进程转化为挂起就绪态。运行态的进程也可以自己挂起自己。</li>
    <li>新建态→挂起就绪态：根据系统当前资源状况和性能要求，可以将新建进程对换出去成为挂起就绪态。</li>
</ul>
<p>
    <mark>挂起的进程将不参与低级调度直到它们被对换进主存。</mark>
</p>
<p>(5)挂起进程具有如下特征</p>
<ul>
    <li>该进程不能立即被执行。</li>
    <li>挂起进程可能会等待事件，但所等待事件是独立于挂起条件的，事件结束并不能导致进程具备执行条件。</li>
    <li>进程进入挂起状态是由于操作系统、父进程或进程本身阻止它的运行。</li>
    <li>结束进程挂起状态的命令只能通过操作系统或父进程发出。</li>
</ul>
<h4>
    <a id="_203" one-link-mark="yes"></a>练习题
</h4>
<p>
    针对分时系统，进程的三种状态之间有几种可能的转换关系？<br> <img
        src="https://img-blog.csdnimg.cn/20201011224752845.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzQ2MDIyNA==,size_16,color_FFFFFF,t_70#pic_center" srcset="/img/loading.gif" lazyload
        alt="在这里插入图片描述"><br>
    在单处理机的分时系统中，分配给进程P的时间片用完后，系统进行切换，结果调度到的仍然是进程P。有可能出现上述情形吗？如果可能请说明理由。<br>
    <strong>解答：</strong><br> 有可能出现上述情况。
</p>
<ul>
    <li>例如,若在进程P时间片用完后，被迫回到就绪队列时，就绪队列为空，这样进程P就是就绪队列中惟一的一个进程，于是调度程序选中的进程必是进程P；</li>
    <li>又如在按优先级调度的系统中，就绪队列按进程优先级排列，在进程P时间片用完之后回到就绪队列时，若其优先级高于当前就绪队列中的其他进程程，则它将排在就绪队列之首，从而再次被调度程序选中并投入运行。</li>
</ul>
<h3>
    <a name="t18" one-link-mark="yes"></a><a name="t18"
        one-link-mark="yes"></a><a id="7_213" one-link-mark="yes"></a>7、进程控制块
</h3>
<p>
    <img
        src="https://img-blog.csdnimg.cn/2020101122572993.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzQ2MDIyNA==,size_16,color_FFFFFF,t_70#pic_center" srcset="/img/loading.gif" lazyload
        alt="在这里插入图片描述"><br> <strong>进程控制块中的信息</strong><br>
    1)进程标识符信息 ：每个进程都必须有一个唯一的标识符
</p>
<ul>
    <li>内部标识符：便于系统使用</li>
    <li>外部标识符：便于用户使用</li>
</ul>
<p>
    2)处理机状态信息(现场信息)<br>
    处理机状态信息主要由处理机的各种寄存器中的内容组成。处理机运行时的信息存放在寄存器中，当被中断时这些信息要存放在PCB中。
</p>
<ul>
    <li>通用寄存器</li>
    <li>指令计数器</li>
    <li>程序状态字PSW</li>
    <li>用户栈指针</li>
    <li>指向该进程页表的指针</li>
</ul>
<p>3)进程调度信息</p>
<ul>
    <li>进程优先级</li>
    <li>进程调度所需的其他信息（执行时间等）</li>
    <li>事件</li>
    <li>进程状态</li>
</ul>
<p>4)进程控制信息</p>
<ul>
    <li>程序和数据的地址</li>
    <li>进程同步和通信机制</li>
    <li>资源清单（打开文件表等）</li>
    <li>链接指针</li>
</ul>
<h4>
    <a id="_242" one-link-mark="yes"></a>练习题
</h4>
<p>
    1.“程序状态字寄存器内容”属于进程控制块的©<br> A、标识信息 <br> B、控制信息<br>
    <mark>C、现场信息</mark>
    <br> D、调度信息
</p>
<p>
    2.进程控制块中的现场信息是在（D）保存的。<br> A、创建进程时<br> B、处理器执行指令时<br>
    C、中断源申请中断时<br>
    <mark>D、中断处理程序处理中断前</mark>
</p>
<p>
    <strong>进程组织方式</strong><br> 1）线性方式:<br> <img
        src="https://img-blog.csdnimg.cn/20201022203057547.png#pic_center" srcset="/img/loading.gif" lazyload
        alt="在这里插入图片描述"><br> <img
        src="https://img-blog.csdnimg.cn/20201022203308470.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzQ2MDIyNA==,size_16,color_FFFFFF,t_70#pic_center" srcset="/img/loading.gif" lazyload
        alt="在这里插入图片描述"><br> 2）索引方式<br> <img
        src="https://img-blog.csdnimg.cn/20201022203419157.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzQ2MDIyNA==,size_16,color_FFFFFF,t_70#pic_center" srcset="/img/loading.gif" lazyload
        alt="在这里插入图片描述"><br> <strong>CPU模式和进程类型</strong><br>
    <img
        src="https://img-blog.csdnimg.cn/20201022203538453.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzQ2MDIyNA==,size_16,color_FFFFFF,t_70#pic_center" srcset="/img/loading.gif" lazyload
        alt="在这里插入图片描述"><br> 进程的两大类：<br>
    系统进程：运行在内核模式，执行操作系统代码；<br> 用户进程：运行在用户模式，执行用户程序代码。
</p>
<h4>
    <a id="_268" one-link-mark="yes"></a>练习题
</h4>
<p>
    1.判断：操作系统通过PCB来控制和管理进程，用户进程也可以对PCB中的信息进行读写操作。<br> <strong>答案：</strong>
    <mark>错误</mark>
</p>
<p>
    2.在一个单处理机系统中，若有10个用户进程，则处于“运行”、“阻塞”、“就绪”状态的进程数量最小和最大值分别可能是多少？<br>
    <strong>答案：</strong><br>
    <mark>
        运行态：最少0个，最多1个；<br> 阻塞态：最少0个，最多10个；<br> 就绪态：最少0个，最多9个。
    </mark>
</p>
<p>
    3.某系统的进程状态变迁如图所示（设该系统的进程调度方式为可剥夺方式）<br> <img
        src="https://img-blog.csdnimg.cn/20201022204252868.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzQ2MDIyNA==,size_16,color_FFFFFF,t_70#pic_center" srcset="/img/loading.gif" lazyload
        alt="在这里插入图片描述"><br> 1）说明进程发生变迁1、3、5的原因；<br>
    2）当发生一个变迁时可能引起另一个变迁的发生，则这两个变迁称为因果变迁。下述因果变迁是否会发生，如果有可能的话，会在什么情况下发生？ (a)
    3→5 (b) 3→2 © 2→1 (d) 4→1 (e) 4→5<br> 3）根据状态变迁图说明该系统的调度策略和调度效果。<br>
    <strong>答案：</strong><br>
    1）系统中当前运行着的进程因中止、结束或等待某个I/O事件而退出运行，并且此时高优先就绪队列中没有等待进程，发生变迁1；<br>
    当运行着的进程发出I/O请求，需要等待I/O事件完成才能继续进行，发生变迁3；<br>
    当有高优先级进程进入就绪队列，并且运行着的进程是低优先级进程时，高优先级进程会抢占CPU，发生变迁5。<br> 2）<br>
    (a) 3→5 是因果变迁；<br> (b) 3→2 不是；<br> © 2→1 是；<br> (d) 4→1
    不是；<br> (e) 4→5 是。<br> 3）此系统采用根据进程优先级分别设置高优先就绪队列和低优先就绪队列：<br>
    高优先进程运行100ms 后就降为低优先就绪队列，以使短进程优先完成；<br>
    对低优先就绪队列中的进程采用时间片轮转法（时间片程度为500ms），确保每个进程都有运行机会；<br>
    同时，对于进行了I/O操作的进程赋予一个高优先级，保证对外界事件可以尽快响应。
</p>
<p>
    4.程序并发执行时失去封闭性和可再现性的主要原因是：<br> <strong>答案：</strong>
    <mark>运行程序的相互制约</mark>
</p>
<p>
    5.处于等待状态的进程也希望占有处理机<br> <strong>答案：</strong>
    <mark>错</mark>
</p>
<p>
    6.简述进程控制块的作用。<br> <strong>答案：</strong>
</p>
<ul>
    <li>进程控制块是进程存在的唯一标志；</li>
    <li>是操作系统对进程进行控制和管理的依据；</li>
    <li>记录进程的各种属性，描述进程的动态变化过程；</li>
    <li>与进程一一对应。</li>
</ul>
<h4>
    <a id="_312" one-link-mark="yes"></a>练习题
</h4>
<p>
    1.系统中有N(N&gt;2)个进程,并且当前没有执行进程调度程序,则(D)不可能发生.<br>
    A.有一个运行进程,没有就绪进程,还有N-1个进程处于等待状态<br> B.有一个运行进程, N-1个就绪进程,
    没有进程处于等待状态<br> C.有一个运行进程和一个就绪进程,还有N-2个进程处于等待状态<br>
    <mark>D.没有运行进程,但有两个就绪进程,还有N-2个进程处于等待状态</mark>
</p>
<p>
    2.在进程管理中，当©时，进程从阻塞状态变为就绪状态。<br> A.进程被进程调度程序选中<br> B.等待某一事件<br>
    <mark>C.等待的事件发生</mark>
    <br> D. 时间片用完
</p>
<p>
    3.分配到必要的资源并获得处理机时的进程状态是(B)。<br> A.就绪状态<br> B.执行状态<br>
    C.阻塞状态<br> D.撤消状态
</p>
<p>
    4．进程的三个基本状态在一定条件下可以相互转化，进程由就绪状态变为运行状态的条件是(D)。<br> A.时间片用完<br>
    B.等待某事件发生<br> C.等待的某事件已发生<br>
    <mark>D.被进程调度程序选中</mark>
    <br> 5．进程的三个基本状态在一定条件下可以相互转化，进程由运行状态变为阻塞状态的条件是(B)。<br>
    A.时间片用完<br>
    <mark>B.等待某事件发生</mark>
    <br> C.等待的某事件已发生<br> D.被进程调度程序选中
</p>
<p>
    6．下列的进程状态变化中，©变化是不可能发生的。<br> A．运行→就绪<br> B．就绪→运行<br>
    <mark>C．等待→运行</mark>
    <br> D．等待→就绪
</p>
<p>
    7．一个运行的进程用完了分配给它的时间片后，它的状态变为(A)。<br>
    <mark>A.就绪</mark>
    <br> B.等待<br> C.运行<br> D.由用户自己确定
</p>
<p>
    8．操作系统通过(B)对进程进行管理。<br> A. JCB<br>
    <mark>B. PCB</mark>
    <br> C. DCT<br> D. CHCT
</p>
<p>
    9．一个进程被唤醒意味着(D)。<br> A. 该进程重新占有了CPU<br> B. 它的优先权变为最大<br>
    C. 其PCB移至等待队列队首<br>
    <mark>D. 进程变为就绪状态</mark>
</p>
<p>
    10．多道程序环境下，操作系统分配资源以©为基本单位。<br> A. 程序<br> B. 指令<br>
    <mark>C. 进程</mark>
    <br> D. 作业
</p>
<h1>
    <a name="t19" one-link-mark="yes"></a><a name="t19"
        one-link-mark="yes"></a><a id="23___372" one-link-mark="yes"></a>2.3
    进程控制
</h1>
<ul>
    <li>进程控制是进程管理中最基本的功能<br> 用于创建和撤销进程；<br> 控制进程状态的转换；
    </li>
    <li>进程控制是操作系统的内核通过原语来实现的</li>
</ul>
<p>
    进程的创建与终止<br> 进程的阻塞与唤醒<br> 进程的挂起与激活
</p>
<p>
    <strong>原语(primitive)</strong>：由若干条指令构成的“原子操作(atomic
    operation)”过程，作为一个整体而不可分割－－要么全都完成，要么全都不做。许多系统调用就是原语。<br> <strong>特征</strong>:“不可中断性”。<br>
    <strong>实现方法</strong>：屏蔽中断。
</p>
<h2>
    <a name="t20" one-link-mark="yes"></a><a name="t20"
        one-link-mark="yes"></a><a id="231___387" one-link-mark="yes"></a>2.3.1
    进程创建
</h2>
<h3>
    <a name="t21" one-link-mark="yes"></a><a name="t21"
        one-link-mark="yes"></a><a id="1___388" one-link-mark="yes"></a>1.
    进程图
</h3>
<ul>
    <li>描述进程的家族关系的有向树.</li>
    <li>进程Pi创建了进程Pj，则Pi是Pj的父进程， Pj是Pi的子进程，用一条由进程Pi指向进程Pj的有向边来描述。</li>
    <li>创建父进程的进程为祖先进程，由此形成进程树，树根为进程家族的祖先。</li>
    <li><img
        src="https://img-blog.csdnimg.cn/20201022211131708.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzQ2MDIyNA==,size_16,color_FFFFFF,t_70#pic_center" srcset="/img/loading.gif" lazyload
        alt="在这里插入图片描述"><br> <strong>计算机系统的启动过程</strong></li>
    <li>BIOS启动（POST加电自检，读取MBR）</li>
    <li>系统引导（bootloder）</li>
    <li>启动内核</li>
    <li>初始化系统</li>
</ul>
<h3>
    <a name="t22" one-link-mark="yes"></a><a name="t22"
        one-link-mark="yes"></a><a id="2_399" one-link-mark="yes"></a>2.引起创建进程的事件
</h3>
<ul>
    <li>用户登录</li>
    <li>作业调度</li>
    <li>提供服务</li>
    <li>应用请求</li>
</ul>
<h4>
    <a id="_406" one-link-mark="yes"></a>练习题
</h4>
<p>
    1.[2009年考研题 24]下列选项中，导致创建新进程的操作是（C）<br> I 用户登陆成功<br> II 设备分配<br>
    III 启动程序执行<br> A、仅I和II<br> B、仅II和III<br>
    <mark>C、仅I和III</mark>
    <br> D、I、II、III
</p>
<h3>
    <a name="t23" one-link-mark="yes"></a><a name="t23"
        one-link-mark="yes"></a><a id="3_416" one-link-mark="yes"></a>3.进程的创建过程
</h3>
<p>
    操作系统发现有创建新进程的事件后，调用进程创建原语(CreateProcess/Fork)创建新进程。<br> 创建过程：<br>
    (1)申请空白PCB<br> (2)为新进程分配资源<br> (3)初始化PCB<br>
    (4)将新进程插入就绪队列<br> <img
        src="https://img-blog.csdnimg.cn/20201022211917178.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzQ2MDIyNA==,size_16,color_FFFFFF,t_70#pic_center" srcset="/img/loading.gif" lazyload
        alt="在这里插入图片描述"><br> <strong>父进程创建子进程与主程序调用子程序有何不同？</strong>
</p>
<ul>
    <li>父进程创建子进程后，父进程与子进程同时执行；</li>
    <li>主程序调用子程序，主程序暂停在调用点，子程序开始执行，直到子程序执行完毕返回，主程序开始执行。</li>
</ul>
<h2>
    <a name="t24" one-link-mark="yes"></a><a name="t24"
        one-link-mark="yes"></a><a id="232___429" one-link-mark="yes"></a>2.3.2
    进程终止
</h2>
<h3>
    <a name="t25" one-link-mark="yes"></a><a name="t25"
        one-link-mark="yes"></a><a id="1___430" one-link-mark="yes"></a>1.
    引起进程终止的事件
</h3>
<ol>
    <li>正常结束</li>
    <li>异常结束<br> 越界错误、保护错、非法指令、特权指令错、运行超时
    </li>
    <li>外界干预</li>
</ol>
<ul>
    <li>操作员或操作系统干预</li>
    <li>父进程请求</li>
    <li>父进程终止</li>
</ul>
<p>
    <strong>进程的终止过程</strong><br> (1)
    根据被终止进程的标识符，从PCB集合中检索出该进程的PCB，从中读出该进程的状态。<br> (2)
    若被终止进程正处于执行状态，应立即终止该进程的执行，置调度标志为真，用于指示该进程被终止后应重新进行进程调度。<br> (3)
    若该进程有子孙进程，应将其所有子孙进程予以终止，以防他们成为不可控的进程。<br> (4)
    将被终止进程所拥有的全部资源，或归还其父进程，或归还系统。<br> (5)
    将被终止进程的PCB从所在队列或链表中移出，挂入空白PCB队列。
</p>
<h2>
    <a name="t26" one-link-mark="yes"></a><a name="t26"
        one-link-mark="yes"></a><a id="233__446" one-link-mark="yes"></a>2.3.3
    进程的阻塞与唤醒
</h2>
<p>(block与wakeup原语)</p>
<h3>
    <a name="t27" one-link-mark="yes"></a><a name="t27"
        one-link-mark="yes"></a><a id="1___448" one-link-mark="yes"></a>1.
    引起进程阻塞的事件
</h3>
<ol>
    <li>请求系统服务</li>
    <li>启动某种操作</li>
    <li>新数据尚未到达</li>
    <li>无新工作可做</li>
</ol>
<h3>
    <a name="t28" one-link-mark="yes"></a><a name="t28"
        one-link-mark="yes"></a><a id="2_454" one-link-mark="yes"></a>2.进程阻塞过程
</h3>
<ul>
    <li>调用阻塞原语阻塞自己，终止该进程的执行，将PCB中的状态改为阻塞，并加入到阻塞队列中；</li>
    <li>然后转进程调度，将处理机分配给另一进程，并进行进程切换以及处理机状态的保护与重新设置。<br> <img
        src="https://img-blog.csdnimg.cn/20201022213225878.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzQ2MDIyNA==,size_16,color_FFFFFF,t_70#pic_center" srcset="/img/loading.gif" lazyload
        alt="在这里插入图片描述"></li>
</ul>
<h3>
    <a name="t29" one-link-mark="yes"></a><a name="t29"
        one-link-mark="yes"></a><a id="3_459" one-link-mark="yes"></a>3.进程唤醒过程
</h3>
<ul>
    <li>阻塞进程等待的事件发生，有关进程调用唤醒原语把等待该事件的进程唤醒。</li>
    <li>把阻塞进程从等待该事件的阻塞队列中移出，将其PCB中的现行状态改为就绪，将PCB插入到就绪队列中。</li>
    <li>阻塞原语与唤醒原语作用相反，成对使用<br> <img
        src="https://img-blog.csdnimg.cn/20201022213420695.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzQ2MDIyNA==,size_16,color_FFFFFF,t_70#pic_center" srcset="/img/loading.gif" lazyload
        alt="在这里插入图片描述"></li>
</ul>
<h2>
    <a name="t30" one-link-mark="yes"></a><a name="t30"
        one-link-mark="yes"></a><a id="234__464" one-link-mark="yes"></a>2.3.4
    进程挂起/激活
</h2>
<p>(suspend/active)</p>
<h3>
    <a name="t31" one-link-mark="yes"></a><a name="t31"
        one-link-mark="yes"></a><a id="1_466" one-link-mark="yes"></a>1.进程的挂起
</h3>
<p>当出现引起进程挂起的事件时，系统利用挂起原语将指定进程挂起。</p>
<ul>
    <li>检查被挂起进程的状态；</li>
    <li>若处于活动就绪，则改为静止就绪；</li>
    <li>若处于活动阻塞，则改为静止阻塞；</li>
    <li>将该进程PCB复制到内存指定区域；</li>
    <li>若挂起的进程正在执行，则重新进行进程调度。</li>
</ul>
<h3>
    <a name="t32" one-link-mark="yes"></a><a name="t32"
        one-link-mark="yes"></a><a id="2_474" one-link-mark="yes"></a>2.进程激活
</h3>
<ul>
    <li>当发生激活进程的事件时，系统利用激活原语将指定进程激活。</li>
    <li>激活原语先将进程从外存调入内存，检查该进程的状态;<br> 若处于静止就绪，则改为活动就绪;<br>
        若处于静止阻塞，则改为活动阻塞;<br> 若采用抢占调度策略，则新进程进入就绪队列时，检查是否要重新进行进程调度。
    </li>
</ul>
<h4>
    <a id="_483" one-link-mark="yes"></a>练习题
</h4>
<p>
    1.只作用于一个进程一次的原语是（A）<br>
    <mark>A.创立</mark>
    <br> B.解挂<br> C.阻塞<br> D.挂起
</p>
<p>
    2.给出用于进程控制的四种常见的原语
    <mark>创建原语</mark>
    、
    <mark>撤消原语</mark>
    、
    <mark>阻塞原语</mark>
    、
    <mark>唤醒原语</mark>
    。
</p>
<p>
    3.操作系统对进程的管理和控制主要是通过控制原语实现的。<br> <strong>错误：</strong>
    <mark>对</mark>
</p>
<p>
    4.原语的执行是屏蔽中断的。<br> <strong>错误：</strong>
    <mark>对</mark>
</p>
</div>
<div
    data-report-view="{&quot;mod&quot;:&quot;1585297308_001&quot;,&quot;dest&quot;:&quot;https://blog.csdn.net/weixin_43460224/article/details/109011551&quot;,&quot;extend1&quot;:&quot;pc&quot;,&quot;ab&quot;:&quot;new&quot;}">
    <div></div>
</div>
<link
    href="https://csdnimg.cn/release/blogv2/dist/mdeditor/css/editerView/markdown_views-d7a94ec6ab.css"
    rel="stylesheet">
<link
    href="https://csdnimg.cn/release/blogv2/dist/mdeditor/css/style-ba784fbaf8.css"
    rel="stylesheet">
</div>
</article>
</div>

                
              </div>
            
            <hr/>
            <div>
              <div class="post-metas my-3">
  
    <div class="post-meta mr-3 d-flex align-items-center">
      <i class="iconfont icon-category"></i>
      

<span class="category-chains">
  
  
    
      <span class="category-chain">
        
  <a href="/categories/%E6%93%8D%E4%BD%9C%E7%B3%BB%E7%BB%9F/" class="category-chain-item">操作系统</a>
  
  

      </span>
    
  
</span>

    </div>
  
  
</div>


              
  

  <div class="license-box my-3">
    <div class="license-title">
      <div>『操作系统』  进程的描述与控制 Part 1 前驱图与程序执行</div>
      <div>http://example.com/2023/12/06/『操作系统』  进程的描述与控制 Part 1 前驱图与程序执行/</div>
    </div>
    <div class="license-meta">
      
        <div class="license-meta-item">
          <div>作者</div>
          <div>Chiam</div>
        </div>
      
      
        <div class="license-meta-item license-meta-date">
          <div>发布于</div>
          <div>2023年12月6日</div>
        </div>
      
      
      
        <div class="license-meta-item">
          <div>许可协议</div>
          <div>
            
              
              
                <a class="print-no-link" target="_blank" href="https://creativecommons.org/licenses/by/4.0/">
                  <span class="hint--top hint--rounded" aria-label="BY - 署名">
                    <i class="iconfont icon-by"></i>
                  </span>
                </a>
              
            
          </div>
        </div>
      
    </div>
    <div class="license-icon iconfont"></div>
  </div>



              
                <div class="post-prevnext my-3">
                  <article class="post-prev col-6">
                    
                    
                      <a href="/2023/12/06/%E3%80%8E%E6%93%8D%E4%BD%9C%E7%B3%BB%E7%BB%9F%E3%80%8F%20%E8%BF%9B%E7%A8%8B%E7%9A%84%E6%8F%8F%E8%BF%B0%E4%B8%8E%E6%8E%A7%E5%88%B6%20Part2%20%E8%BF%9B%E7%A8%8B%E5%90%8C%E6%AD%A5/" title="『操作系统』 进程的描述与控制 Part2 进程同步">
                        <i class="iconfont icon-arrowleft"></i>
                        <span class="hidden-mobile">『操作系统』 进程的描述与控制 Part2 进程同步</span>
                        <span class="visible-mobile">上一篇</span>
                      </a>
                    
                  </article>
                  <article class="post-next col-6">
                    
                    
                      <a href="/2023/12/06/%E3%80%8E%E5%BC%80%E5%8F%91%E3%80%8F%E8%BD%AF%E4%BB%B6%E5%B7%A5%E7%A8%8B-%E6%A6%82%E8%BF%B0/" title="『开发』软件工程-概述">
                        <span class="hidden-mobile">『开发』软件工程-概述</span>
                        <span class="visible-mobile">下一篇</span>
                        <i class="iconfont icon-arrowright"></i>
                      </a>
                    
                  </article>
                </div>
              
            </div>

            
  
  
    <article id="comments" lazyload>
      
  <div id="valine"></div>
  <script type="text/javascript">
    Fluid.utils.loadComments('#valine', function() {
      Fluid.utils.createScript('https://lib.baomitu.com/valine/1.5.1/Valine.min.js', function() {
        var options = Object.assign(
          {"appId":"fIfc7WqUDZohlQuPc2lz5mJy-MdYXbMMI","appKey":"zjlAG3ZA3o4cBHVAkjzc2Z20","path":"window.location.pathname","placeholder":"留言仅限讨论，禁止广告等行为","avatar":"retro","meta":["nick","mail","link"],"requiredFields":[],"pageSize":10,"lang":"zh-CN","highlight":false,"recordIP":false,"serverURLs":"https://fifc7wqu.api.lncldglobal.com","emojiCDN":null,"emojiMaps":null,"enableQQ":false},
          {
            el: "#valine",
            path: window.location.pathname
          }
        )
        new Valine(options);
        Fluid.utils.waitElementVisible('#valine .vcontent', () => {
          var imgSelector = '#valine .vcontent img:not(.vemoji)';
          Fluid.plugins.imageCaption(imgSelector);
          Fluid.plugins.fancyBox(imgSelector);
        })
      });
    });
  </script>
  <noscript>Please enable JavaScript to view the comments</noscript>


    </article>
  


          </article>
        </div>
      </div>
    </div>

    <div class="side-col d-none d-lg-block col-lg-2">
      
  <aside class="sidebar" style="margin-left: -1rem">
    <div id="toc">
  <p class="toc-header">
    <i class="iconfont icon-list"></i>
    <span>目录</span>
  </p>
  <div class="toc-body" id="toc-body"></div>
</div>



  </aside>


    </div>
  </div>
</div>





  



  



  



  



  







    

    
      <a id="scroll-top-button" aria-label="TOP" href="#" role="button">
        <i class="iconfont icon-arrowup" aria-hidden="true"></i>
      </a>
    

    
      <div class="modal fade" id="modalSearch" tabindex="-1" role="dialog" aria-labelledby="ModalLabel"
     aria-hidden="true">
  <div class="modal-dialog modal-dialog-scrollable modal-lg" role="document">
    <div class="modal-content">
      <div class="modal-header text-center">
        <h4 class="modal-title w-100 font-weight-bold">搜索</h4>
        <button type="button" id="local-search-close" class="close" data-dismiss="modal" aria-label="Close">
          <span aria-hidden="true">&times;</span>
        </button>
      </div>
      <div class="modal-body mx-3">
        <div class="md-form mb-5">
          <input type="text" id="local-search-input" class="form-control validate">
          <label data-error="x" data-success="v" for="local-search-input">关键词</label>
        </div>
        <div class="list-group" id="local-search-result"></div>
      </div>
    </div>
  </div>
</div>

    

    
  </main>

  <footer>
    <div class="footer-inner">
  
    <div class="footer-content">
       <meta name="referrer" content="no-referrer" /> <footer id="footer" role="contentinfo"> <div class="divider"> <div class="wall"></div> <img class="animals" src="/img/footer_animals_new.png" srcset="/img/loading.gif" lazyload alt="Footer Animals"> </div> <div class="container" data-index="450"> <p> <a href="https://chiamzhang.github.io" target="_blank">DogEgg</a> <i class="iconfont icon-love"></i> <a href="#" target="_blank">LittePig</a> </p> <p> Powered by  <a href="https://hexo.io" target="_blank" rel="nofollow noopener"><span>Hexo</span></a> <i class="iconfont icon-pen"></i> Theme  <a href="https://github.com/fluid-dev/hexo-theme-fluid" target="_blank" rel="nofollow noopener"><span>Fluid</span></a> </p> </div> </footer> 
    </div>
  
  
  
  
</div>

  </footer>

  <!-- Scripts -->
  
  <script  src="https://lib.baomitu.com/nprogress/0.2.0/nprogress.min.js" ></script>
  <link  rel="stylesheet" href="https://lib.baomitu.com/nprogress/0.2.0/nprogress.min.css" />

  <script>
    NProgress.configure({"showSpinner":false,"trickleSpeed":100})
    NProgress.start()
    window.addEventListener('load', function() {
      NProgress.done();
    })
  </script>


<script  src="https://lib.baomitu.com/jquery/3.6.4/jquery.min.js" ></script>
<script  src="https://lib.baomitu.com/twitter-bootstrap/4.6.1/js/bootstrap.min.js" ></script>
<script  src="/js/events.js" ></script>
<script  src="/js/plugins.js" ></script>


  <script  src="https://lib.baomitu.com/typed.js/2.0.12/typed.min.js" ></script>
  <script>
    (function (window, document) {
      var typing = Fluid.plugins.typing;
      var subtitle = document.getElementById('subtitle');
      if (!subtitle || !typing) {
        return;
      }
      var text = subtitle.getAttribute('data-typed-text');
      
        typing(text);
      
    })(window, document);
  </script>




  
    <script  src="/js/img-lazyload.js" ></script>
  




  
<script>
  Fluid.utils.createScript('https://lib.baomitu.com/tocbot/4.20.1/tocbot.min.js', function() {
    var toc = jQuery('#toc');
    if (toc.length === 0 || !window.tocbot) { return; }
    var boardCtn = jQuery('#board-ctn');
    var boardTop = boardCtn.offset().top;

    window.tocbot.init(Object.assign({
      tocSelector     : '#toc-body',
      contentSelector : '.markdown-body',
      linkClass       : 'tocbot-link',
      activeLinkClass : 'tocbot-active-link',
      listClass       : 'tocbot-list',
      isCollapsedClass: 'tocbot-is-collapsed',
      collapsibleClass: 'tocbot-is-collapsible',
      scrollSmooth    : true,
      includeTitleTags: true,
      headingsOffset  : -boardTop,
    }, CONFIG.toc));
    if (toc.find('.toc-list-item').length > 0) {
      toc.css('visibility', 'visible');
    }

    Fluid.events.registerRefreshCallback(function() {
      if ('tocbot' in window) {
        tocbot.refresh();
        var toc = jQuery('#toc');
        if (toc.length === 0 || !tocbot) {
          return;
        }
        if (toc.find('.toc-list-item').length > 0) {
          toc.css('visibility', 'visible');
        }
      }
    });
  });
</script>


  <script src=https://lib.baomitu.com/clipboard.js/2.0.11/clipboard.min.js></script>

  <script>Fluid.plugins.codeWidget();</script>


  
<script>
  Fluid.utils.createScript('https://lib.baomitu.com/anchor-js/4.3.1/anchor.min.js', function() {
    window.anchors.options = {
      placement: CONFIG.anchorjs.placement,
      visible  : CONFIG.anchorjs.visible
    };
    if (CONFIG.anchorjs.icon) {
      window.anchors.options.icon = CONFIG.anchorjs.icon;
    }
    var el = (CONFIG.anchorjs.element || 'h1,h2,h3,h4,h5,h6').split(',');
    var res = [];
    for (var item of el) {
      res.push('.markdown-body > ' + item.trim());
    }
    if (CONFIG.anchorjs.placement === 'left') {
      window.anchors.options.class = 'anchorjs-link-left';
    }
    window.anchors.add(res.join(', '));

    Fluid.events.registerRefreshCallback(function() {
      if ('anchors' in window) {
        anchors.removeAll();
        var el = (CONFIG.anchorjs.element || 'h1,h2,h3,h4,h5,h6').split(',');
        var res = [];
        for (var item of el) {
          res.push('.markdown-body > ' + item.trim());
        }
        if (CONFIG.anchorjs.placement === 'left') {
          anchors.options.class = 'anchorjs-link-left';
        }
        anchors.add(res.join(', '));
      }
    });
  });
</script>


  
<script>
  Fluid.utils.createScript('https://lib.baomitu.com/fancybox/3.5.7/jquery.fancybox.min.js', function() {
    Fluid.plugins.fancyBox();
  });
</script>


  <script>Fluid.plugins.imageCaption();</script>

  <script  src="/js/local-search.js" ></script>




  
<script src="/js/love.js"></script>
<script src="/js/funnyTitle.js"></script>
<script src="/js/backTop.js"></script>
<script src="//cdn.jsdelivr.net/gh/bynotes/texiao/source/js/xiaoxuehua.js"></script>



<!-- 主题的启动项，将它保持在最底部 -->
<!-- the boot of the theme, keep it at the bottom -->
<script  src="/js/boot.js" ></script>


  

  <noscript>
    <div class="noscript-warning">博客在允许 JavaScript 运行的环境下浏览效果更佳</div>
  </noscript>
<script src="/live2dw/lib/L2Dwidget.min.js?094cbace49a39548bed64abff5988b05"></script><script>L2Dwidget.init({"pluginRootPath":"live2dw/","pluginJsPath":"lib/","pluginModelPath":"assets/","tagMode":false,"debug":false,"model":{"jsonPath":"/live2dw/assets/wanko.model.json"},"display":{"position":"left","width":150,"height":150,"hOffset":20,"vOffset":0},"mobile":{"show":false,"scale":0.5},"react":{"opacity":0.9},"log":false});</script></body>
</html>
